会员11.11
消息
历史
创作中心
发布

不一样的网络协议-------KCP协议

已于 2023-10-31 07:58:32 修改
阅读量1.5k 收藏 18
点赞数 15
文章标签： 网络 c++ linux 网络协议 kcp协议
版权

1、kcp 的协议特点

1.1、RTO 不翻倍

RTO(Retransmission TimeOut)，重传超时时间。tcp x 2，kcp x 1.5，提高传输速度

1.2、选择重传
TCP丢包时会全部重传从该包开始以后的数据，而KCP选择性重传，只重传真正丢失的数据包。

1.3、快速重传
tcp 重传模式

   超时重传：超过规定的时间 RTO 则重传
   快速重传：收到三个冗余ACK，不去等待RTO ，直接重传
   这里指的是收到fastresend个失序报文后，不等待超时，直接重传，减少丢包等待时间。

1.4、非延迟 ACK
tcp 为充分利用带宽，延迟发送 ACK，RTT 时间较大，延长了丢包时的判断过程。而 kcp 的 ACK 是否延迟发送可以调节。

1.5、ACK + UNA
ARQ （自动重传请求，Automatic Repeat-reQuest）模型响应有两种方式

UNA：此编号前所有包已收到，tcp
ACK：该编号包已收到
只用 UNA 将导致全部重传，只用 ACK 则丢失成本太高，以往协议都是二选其一。而 kcp 协议中，除去单独的 ACK 包（精确）外，所有包都有 UNA 信息。

1.6、非退让流控
KCP正常模式同TCP一样使用公平退让法则，即发送窗口大小由：发送缓存大小、接收端剩余接收缓存大小、丢包退让、慢启动这四要素决定。但传送及时性要求很高的小数据时，可选择仅用前两项来控制发送频率。以牺牲部分公平性及带宽利用率之代价，换取了流畅传输的效果。

KCP 实时性好，但带宽利用率较低，因为

非退让流控，不断尝试发送数据，有效包不多
每个包应答，占用一定的带宽

2.kcp 实现

UDP收到的报文通过kcp_input传递给KCP，KCP会对数据进行解包，重新封装成应用层用户数据，应用层通过kcp_recv获取。应用层通过kcp_send发送数据，KCP会把用户数据拆分kcp报文，通过kcp_output，以UDP(send)的方式发送。

 

2.1、kcp 数据结构

kcp 报文结构：

conv：会话编号，通信双方必须一致。
cmd：报文类型
IKCP_CMD_ACK 确认命令
IKCP_CMD_PUSH 数据推送命令
IKCP_CMD_WASK 接收窗口询问大小命令
IKCP_CMD_WINS 接收窗口大小告知命令
wnd: 己方可用接收窗口大小，接收窗口大小 - 接收队列大小
frg：segmen t分片。0，最后一个分片。3 2 1 0
sn：segment 报文的序列号。
ts：发送时间戳，用于计算RTO和RTT
una：待接收的序列号，其实确认号，表示该序列号之前的所有报文都收到了，可以删除
len：数据长度，DATA的长度
DATA: 用户数据


kcp 使用的 Segment 定义如下

  1. struct IKCPSEG
  2. {
  3.     struct IQUEUEHEAD node;	// 用来串接多个 KCP segment，即前向后向指针
  4.     IUINT32 conv;   // 会话编号
  5.     IUINT32 cmd;    // 报文类型
  6.     IUINT32 frg;    // 分片   
  7.     IUINT32 wnd;    // 可用接收窗口大小(接收窗口大小-接收队列大小)
  8.     IUINT32 ts;     // 发送时刻的时间戳
  9.     IUINT32 sn;     // 分片 segment 的序号
  10.     IUINT32 una;    // 待接收消息序号
  11.     IUINT32 len;    // 数据长度
  12.     IUINT32 resendts;	// 下次超时重传该报文的时间戳
  13.     IUINT32 rto;	    // 重传超时时间
  14.     //发送端在发送过程中携带着RTO，该发送端会启动一个定时器，进行定时，如果超过RTO就会重传
  15.     IUINT32 fastack;    // 收到ack时该分片被跳过的次数，用于快速重传
  16.     IUINT32 xmit;       // 记录了该报文被传输了几次
  17.     char data[1];		// 实际传输的数据 payload
  18. };

每一个 KCP 用户都需要调用 ikcp_create 创建一个 kcp 控制块 ikcpcb。ikcpcb 结构用来实现整个 KCP 协议。

  1. struct IKCPCB
  2. {
  3.     IUINT32 conv;   // 标识会话
  4.     IUINT32 mtu;    // 最大传输单元,默认数据为1400,最小为50
  5.     IUINT32 mss;    // 最大分片大小,不大于mtu
  6.     IUINT32 state;  // 连接状态(0xffffffff表示断开连接)
  7.     
  8.     IUINT32 snd_una;    // 第一个未确认的包
  9.     IUINT32 snd_nxt;    // 下一个待分配包的序号
  10.     IUINT32 rcv_nxt;    // 待接收消息序号.为了保证包的顺序,接收方会维护一个接收窗口,接收窗口有一个起始序号rcv_nxt 以及尾序号rcv_nxt + rcv_wnd(接收窗口大小)
  11.  
  12.     IUINT32 ts_recent;  
  13.     IUINT32 ts_lastack;
  14.     IUINT32 ssthresh;       // 拥塞窗口的阈值
  15.     
  16.     IINT32  rx_rttval;      // RTT的变化量,代表连接的抖动情况
  17.     IINT32  rx_srtt;        // smoothed round trip time，平滑后的RTT；
  18.     IINT32  rx_rto;         // 收ACK接收延迟计算出来的重传超时时间
  19.     IINT32  rx_minrto;      // 最小重传超时时间
  20.  
  21.     IUINT32 snd_wnd;        // 发送窗口大小
  22.     IUINT32 rcv_wnd;        // 接收窗口大小，本质上而言如果接收端一直不去读取数据则rcv_queue就会满(达到rcv_wnd)
  23.     IUINT32 rmt_wnd;        // 远端接收窗口大小
  24.     IUINT32 cwnd;           // 拥塞窗口大小, 动态变化
  25.     IUINT32 probe;          // 探查变量, IKCP_ASK_TELL表示告知远端窗口大小。IKCP_ASK_SEND表示请求远端告知窗口大小；
  26.  
  27.     IUINT32 current;
  28.     IUINT32 interval;       // 内部flush刷新间隔，对系统循环效率有非常重要影响, 间隔小了cpu占用率高, 间隔大了响应慢
  29.     IUINT32 ts_flush;       // 下次flush刷新的时间戳
  30.     IUINT32 xmit;           // 发送segment的次数, 当segment的xmit增加时，xmit增加(重传除外)
  31.  
  32.     IUINT32 nrcv_buf;       // 接收缓存中的消息数量
  33.     IUINT32 nsnd_buf;       // 发送缓存中的消息数量
  34.  
  35.     IUINT32 nrcv_que;       // 接收队列中消息数量
  36.     IUINT32 nsnd_que;       // 发送队列中消息数量
  37.  
  38.     IUINT32 nodelay;        // 是否启动无延迟模式。无延迟模式rtomin将设置为0，拥塞控制不启动；
  39.     IUINT32 updated;         //是否调用过update函数的标识；
  40.  
  41.     IUINT32 ts_probe;       // 下次探查窗口的时间戳；
  42.     IUINT32 probe_wait;     // 探查窗口需要等待的时间；
  43.  
  44.     IUINT32 dead_link;      // 最大重传次数，被认为连接中断；
  45.     IUINT32 incr;           // 可发送的最大数据量；
  46.  
  47.     struct IQUEUEHEAD snd_queue;    //发送消息的队列 
  48.     struct IQUEUEHEAD rcv_queue;    //接收消息的队列, 确认过用户可读取
  49.     struct IQUEUEHEAD snd_buf;      //发送消息的缓存
  50.     struct IQUEUEHEAD rcv_buf;      //接收消息的缓存
  51.  
  52.     IUINT32 *acklist;   //待发送的ack的列表 当收到一个数据报文时，将其对应的 ACK 报文的 sn 号以及时间戳 ts 
  53.                         //同时加入到acklist 中，即形成如 [sn1, ts1, sn2, ts2 …] 的列表
  54.     IUINT32 ackcount;   // 记录 acklist 中存放的 ACK 报文的数量 
  55.     IUINT32 ackblock;   // acklist 数组的可用长度，当 acklist 的容量不足时，需要进行扩容
  56.  
  57.     void *user;     // 指针，可以任意放置代表用户的数据，也可以设置程序中需要传递的变量；
  58.     char *buffer;   // 存储字节流信息 
  59.  
  60.     int fastresend; // 触发快速重传的重复ACK个数；
  61.     int fastlimit;
  62.  
  63.     int nocwnd;     // 取消拥塞控制
  64.     int stream;     // 是否采用流传输模式
  65.  
  66.     int logmask;    // 日志的类型，如IKCP_LOG_IN_DATA，方便调试
  67.  
  68.     int (*output)(const char *buf, int len, struct IKCPCB *kcp, void *user);//发送消息的回调函数
  69.     void (*writelog)(const char *log, struct IKCPCB *kcp, void *user);  // 写日志的回调函数
  70. };
2.2、kcp 报文发送

KCP 中，数据发送流程分为：

  • 上层应用调用 ikcp_send 将数据写入 snd_queue
  • 下层函数 ikcp_flush 决定将多少数据从 snd_queue 移动到 snd_buf，进行发送

 

ikcp_send 

 ikcp_send

ikcp_send 的功能：把用户发送的数据根据MSS分片成KCP的数据包格式，插入待发送队列

分片方式

流模式：检测每个发送队列⾥的分片是否达到 MSS，没有达到则用新的数据填充分片。
消息模式：将用户数据的每个分片设置 sn 和 frag，将分片后的数据存入发送队列，接收方通过 sn 和 frag 解包。即使⼀个分片的数据量可能不能达到MSS，也会作为⼀个包发送出去。
 

  1. int ikcp_send(ikcpcb *kcp, const char *buffer, int len) 
  2. {
  3.     // 1、如果KCP开启流模式
  4. 	if (kcp->stream != 0) {		
  5. 		if (!iqueue_is_empty(&kcp->snd_queue)) {
  6. 			// 取出 snd_queue 中的最后一个报文，将其填充到 mss 的长度，设置frg为0
  7. 			IKCPSEG *old = iqueue_entry(kcp->snd_queue.prev, IKCPSEG, node);
  8.             
  9. 			// 旧分片内数据长度小于mss
  10. 			if (old->len < kcp->mss) {
  11. 				int capacity = kcp->mss - old->len; // 还能容纳的数据长度
  12. 				int extend = (len < capacity)? len : capacity; // 需要填充的长度
  13. 				seg = ikcp_segment_new(kcp, old->len + extend); // 新建segment
  14. 				assert(seg);
  15. 				if (seg == NULL) {
  16. 					return -2;
  17. 				}
  18.                  // 新分片添加到发送队列尾部
  19. 				iqueue_add_tail(&seg->node, &kcp->snd_queue);   
  20.                  // 拷贝旧分片的数据到新分片
  21. 				memcpy(seg->data, old->data, old->len); 
  22. 				// 将buffer中的数据也拷贝到新分片
  23. 				if (buffer) {
  24. 					memcpy(seg->data + old->len, buffer, extend);
  25. 					buffer += extend; // buffer指向剩余数据的开头
  26. 				}
  27. 				seg->len = old->len + extend;
  28. 				seg->frg = 0;
  29. 				len -= extend; // 更新len为剩余数据长度
  30. 				iqueue_del_init(&old->node); // 删除old
  31. 				ikcp_segment_delete(kcp, old);
  32. 			}
  33. 		}
  34. 		if (len <= 0) {
  35. 			return 0;
  36. 		}
  37. 	}
  38.     
  39.     // 2、计算数据需要分成多少段报文
  40.     if (len <= (int)kcp->mss) count = 1; // mss 1376 + head 24 = mtu 1400
  41.     else count = (len + kcp->mss - 1) / kcp->mss;
  42. 	if (count >= (int)IKCP_WND_RCV) return -2;  // 超过对方的初始接收窗口
  43. 	if (count == 0) count = 1;  
  44.     
  45.     // fragment
  46.     // 3、将数据全部新建 segment 插入发送队列尾部，队列计数递增, frag 递减
  47.     for (i = 0; i < count; i++) {
  48.         int size = len > (int)kcp->mss ? (int)kcp->mss : len;
  49.         seg = ikcp_segment_new(kcp, size);
  50.         assert(seg);
  51.         if (seg == NULL) {
  52.             return -2;
  53.         }
  54.         if (buffer && len > 0) { // 仍有待发送的数据
  55.             memcpy(seg->data, buffer, size);
  56.         }
  57.         seg->len = size;
  58.         // 分片编号，逆序。流模式情况下分片编号不用填写
  59.         seg->frg = (kcp->stream == 0)? (count - i - 1) : 0;
  60.         iqueue_init(&seg->node);
  61.         iqueue_add_tail(&seg->node, &kcp->snd_queue); // 加入到 snd_queue 中
  62.         kcp->nsnd_que++;
  63.        
  64.         if (buffer) {
  65. 		      buffer += size;
  66.         }
  67.         len -= size;
  68.     }
  69. }

 应用层调用 ikcp_send 之后将用户数据置入 snd_queue 中，当 KCP 调用 ikcp_flush 时才将数据从 snd_queue 中 移入到 snd_buf 中，然后调用 kcp->output() 发送。

检查 kcp->update 是否更新，未更新直接返回。kcp->update 由 ikcp_update 更新，上层应用需要每隔一段时间（10-100ms）调用 ikcp_update 来驱动 KCP 发送数据；

  1. // 'ikcp_update' haven't been called. 
  2. if (kcp->updated == 0) return;

准备将 acklist 中记录的 ACK 报文发送出去，即从 acklist 中填充 ACK 报文的 sn 和 ts 字段；

  1. // flush acknowledges
  2. // 逐一获取 acklist 中的 sn 和 ts，编码成 segment，以流的方式凑够 MTU 发送
  3. count = kcp->ackcount;		// 需要应答的分片数量
  4. for (i = 0; i < count; i++) {
  5.     size = (int)(ptr - buffer);
  6.     // 超过 MTU 大小直接发送
  7.     if (size + (int)IKCP_OVERHEAD > (int)kcp->mtu) {
  8.         ikcp_output(kcp, buffer, size);
  9.         ptr = buffer; // 新建分片
  10.     }
  11.     ikcp_ack_get(kcp, i, &seg.sn, &seg.ts); // 应答包
  12.     ptr = ikcp_encode_seg(ptr, &seg);       // 编码segment协议头
  13. }
  14.  
  15. kcp->ackcount = 0;

检查当前是否需要对远端窗口进行探测。由于 KCP 流量控制依赖于远端通知其可接受窗口的大小，一旦远端接受窗口 kcp->rmt_wnd 为0，那么本地将不会再向远端发送数据，因此就没有机会从远端接受 ACK 报文，从而没有机会更新远端窗口大小。在这种情况下，KCP 需要发送窗口探测报文到远端，待远端回复窗口大小后，后续传输可以继续：
 

  1. // probe window size (if remote window size equals zero)
  2. // 1、远端窗口大小为0，需要发送窗口探测报文
  3. if (kcp->rmt_wnd == 0) {
  4.     // 初始化探测间隔和下一次探测时间
  5.     if (kcp->probe_wait == 0) { 
  6.         kcp->probe_wait = IKCP_PROBE_INIT;  // 默认7秒探测
  7.         kcp->ts_probe = kcp->current + kcp->probe_wait; // 下一次探测时间
  8.     }	
  9.     else {
  10.         //远端窗口为0，发送过探测请求，但是已经超过下次探测的时间  
  11.         // 检测是否到了探测时间
  12.         if (_itimediff(kcp->current, kcp->ts_probe) >= 0) { 
  13.             // 更新探测间隔probe_wait
  14.             if (kcp->probe_wait < IKCP_PROBE_INIT) 
  15.                 kcp->probe_wait = IKCP_PROBE_INIT;
  16.             kcp->probe_wait += kcp->probe_wait / 2;
  17.             if (kcp->probe_wait > IKCP_PROBE_LIMIT)
  18.                 kcp->probe_wait = IKCP_PROBE_LIMIT;
  19.             // 更新下次探测时间ts_probe
  20.             kcp->ts_probe = kcp->current + kcp->probe_wait;
  21.             // 更新探测变量probe为IKCP_ASK_SEND，发送探测消息 
  22.             kcp->probe |= IKCP_ASK_SEND;
  23.         }
  24.     }
  25. }	
  26. // 2、远端窗口正常，则不需要发送窗口探测  
  27. else {
  28.     kcp->ts_probe = 0;	// 更新下次探测时间为0
  29.     kcp->probe_wait = 0; // 更新探测窗口等待时间为0
  30. }

 将窗口探测报文和窗口回复报文发送出去

  1. // flush window probing commands
  2. if (kcp->probe & IKCP_ASK_SEND) {
  3.     seg.cmd = IKCP_CMD_WASK;	// 窗口探测[询问对方窗口size]
  4.     size = (int)(ptr - buffer);
  5.     if (size + (int)IKCP_OVERHEAD > (int)kcp->mtu) {
  6.         ikcp_output(kcp, buffer, size);
  7.         ptr = buffer;
  8.     }
  9.     ptr = ikcp_encode_seg(ptr, &seg);
  10. }
  11.  
  12. // flush window probing commands
  13. if (kcp->probe & IKCP_ASK_TELL) {
  14.     seg.cmd = IKCP_CMD_WINS;	// 窗口告知[告诉对方我方窗口size]
  15.     size = (int)(ptr - buffer);
  16.     if (size + (int)IKCP_OVERHEAD > (int)kcp->mtu) {
  17.         ikcp_output(kcp, buffer, size);
  18.         ptr = buffer;
  19.     }
  20.     ptr = ikcp_encode_seg(ptr, &seg);
  21. }
  22.  
  23. kcp->probe = 0;	//清空标识

 计算本次发送可用的窗口大小，这里 KCP 采用了可以配置的策略，正常情况下，KCP 的窗口大小由发送窗口 snd_wnd，远端接收窗口 rmt_wnd 以及根据流控计算得到的 kcp->cwnd 共同决定；但是当开启了 nocwnd 模式时，窗口大小仅由前两者决定；

  1. // calculate window size 
  2. // 若没有流控，取发送窗口和远端接收窗口最小值
  3. cwnd = _imin_(kcp->snd_wnd, kcp->rmt_wnd);      
  4. // 若存在流控，则取当前拥塞窗口、发送窗口和远端接收窗口三者最小值
  5. if (kcp->nocwnd == 0) cwnd = _imin_(kcp->cwnd, cwnd);

 将缓存在 snd_queue 中的数据移到 snd_buf 中等待发送

  1. // move data from snd_queue to snd_buf
  2. // 从snd_queue移动到snd_buf的数量不能超出对方的接收能力，发送符合拥塞范围的分片
  3. while (_itimediff(kcp->snd_nxt, kcp->snd_una + cwnd) < 0) {
  4.     IKCPSEG *newseg;
  5.     if (iqueue_is_empty(&kcp->snd_queue)) break;
  6.  
  7.     newseg = iqueue_entry(kcp->snd_queue.next, IKCPSEG, node);
  8. 	
  9.     iqueue_del(&newseg->node);
  10.     iqueue_add_tail(&newseg->node, &kcp->snd_buf); // 添加到发送缓存
  11.     kcp->nsnd_que--;
  12.     kcp->nsnd_buf++;
  13.     //设置数据分片的属性
  14.     newseg->conv = kcp->conv;
  15.     newseg->cmd = IKCP_CMD_PUSH;
  16.     newseg->wnd = seg.wnd;	// 告知对方当前的接收窗口
  17.     newseg->ts = current;	// 当前时间
  18.     newseg->sn = kcp->snd_nxt++;	// 序号
  19.     newseg->una = kcp->rcv_nxt;		// 告诉对方可以发送的下一个包序号
  20.     newseg->resendts = current;		// 当前发送的时间
  21.     newseg->rto = kcp->rx_rto;		// 超时重传的时间
  22.     newseg->fastack = 0;			// 是否快速重传
  23.     newseg->xmit = 0;				// 重传次数
  24. }

 在发送数据之前，先设置快重传的次数和重传间隔；KCP 允许设置快重传的次数，即 fastresend 参数。例如设置 fastresend 为2，并且发送端发送了1,2,3,4,5几个包，收到远端的ACK: 1, 3, 4, 5，当收到ACK3时，KCP知道2被跳过1次，收到ACK4时，知道2被**“跳过”**了2次，此时可以认为2号丢失，不用等超时，直接重传2号包；每个报文的 fastack 记录了该报文被跳过了几次，由函数 ikcp_parse_fastack 更新。于此同时，KCP 也允许设置 nodelay 参数，当激活该参数时，每个报文的超时重传时间将由 x2 变为 x1.5，即加快报文重传：

  1. // calculate resent 
  2. // 是否设置快重传次数
  3. resent = (kcp->fastresend > 0)? (IUINT32)kcp->fastresend : 0xffffffff; 
  4. // 是否开启nodelay
  5. rtomin = (kcp->nodelay == 0)? (kcp->rx_rto >> 3) : 0;

将 snd_buf 中的数据发送出去

  1. // flush data segments
  2. // 发送snd buf的分片，只要数据还在snd_buf 说明对方还没有应答
  3. // 1、新的报文，正常发送
  4. // 2、超时重传
  5. // 3、快速重传（如果有）
  6. for (p = kcp->snd_buf.next; p != &kcp->snd_buf; p = p->next) {
  7.     IKCPSEG *segment = iqueue_entry(p, IKCPSEG, node);
  8.     int needsend = 0;
  9.     // 1、如果该报文是第一次传输，那么直接发送
  10.     if (segment->xmit == 0) {   
  11.         needsend = 1;
  12.         segment->xmit++; // 分片发送次数 + 1
  13.         segment->rto = kcp->rx_rto; // 超时时间间隔
  14.         segment->resendts = current + segment->rto + rtomin; // 下一次要发送的时间
  15.     }
  16.     // 2、当前时间达到了该报文的重传时间，但并没有新的ack到达，出现丢包, 重传  
  17.     else if (_itimediff(current, segment->resendts) >= 0) { 
  18.         needsend = 1;
  19.         segment->xmit++;
  20.         kcp->xmit++;
  21.         // 根据 nodelay 参数更新重传时间
  22.         if (kcp->nodelay == 0) {
  23.             segment->rto += _imax_(segment->rto, (IUINT32)kcp->rx_rto);
  24.         } else {
  25.             IINT32 step = (kcp->nodelay < 2)? ((IINT32)(segment->rto)) : kcp->rx_rto;
  26.             segment->rto += step / 2; //报文超时等待时间更新，控制RTO=1.5 
  27.         }
  28.         segment->resendts = current + segment->rto;	//下一次发送的时间
  29.         lost = 1;	// 丢包，反应到拥塞控制策略去了
  30.     }
  31.     // 3、该报文的的被跳过次数超过设置的快速重传次数，需要重传  
  32.     else if (segment->fastack >= resent) {  
  33.         if ((int)segment->xmit <= kcp->fastlimit || kcp->fastlimit <= 0) {
  34.             needsend = 1;
  35.             segment->xmit++;
  36.             segment->fastack = 0;  // 重置该分片被跳过的次数
  37.             segment->resendts = current + segment->rto;
  38.             change++;	// 标识快速重传的发生
  39.         }
  40.     }
  41.  
  42.     // 需要发送数据
  43.     if (needsend) {
  44.         int need;
  45.         segment->ts = current;
  46.         segment->wnd = seg.wnd; // 己方可用接收窗口大小
  47.         segment->una = kcp->rcv_nxt;   // 待接收的下一个包序号
  48.  
  49.         size = (int)(ptr - buffer);
  50.         need = IKCP_OVERHEAD + segment->len;
  51.  
  52.         // 小包封装成大包发送
  53.         if (size + need > (int)kcp->mtu) {		
  54.             ikcp_output(kcp, buffer, size);
  55.             ptr = buffer;
  56.         }
  57.  
  58.         // 把segment封装成线性buffer发送 头部+数据
  59.         ptr = ikcp_encode_seg(ptr, segment);    
  60.  
  61.         if (segment->len > 0) {
  62.             memcpy(ptr, segment->data, segment->len);
  63.             ptr += segment->len;
  64.         }
  65.  
  66.         if (segment->xmit >= kcp->dead_link) {
  67.             kcp->state = (IUINT32)-1;
  68.         }
  69.     }
  70. }
  71.  
  72. // flash remain segments
  73. size = (int)(ptr - buffer);	// 剩余的数据
  74. // 最终只要有数据要发送，一定发出去
  75. if (size > 0) {
  76.     ikcp_output(kcp, buffer, size);	
  77. }

 根据设置的 lost 和 change 更新窗口大小；注意 快重传和丢包时的窗口更新算法不一致，这一点类似于 TCP 协议的拥塞控制和快恢复算法

  1. // update ssthresh
  2. //如果发生了快速重传，拥塞窗口阈值降低为当前未确认包数量的一半或最小值 
  3. if (change) {   
  4.     IUINT32 inflight = kcp->snd_nxt - kcp->snd_una;
  5.     kcp->ssthresh = inflight / 2;
  6.     if (kcp->ssthresh < IKCP_THRESH_MIN)
  7.         kcp->ssthresh = IKCP_THRESH_MIN;
  8.     kcp->cwnd = kcp->ssthresh + resent;	// 动态调整拥塞控制窗口
  9.     kcp->incr = kcp->cwnd * kcp->mss;
  10. }
  11. // 如果发生了丢包，阈值减半, cwd 窗口保留为 1
  12. if (lost) {     
  13.     kcp->ssthresh = cwnd / 2;
  14.     if (kcp->ssthresh < IKCP_THRESH_MIN)
  15.         kcp->ssthresh = IKCP_THRESH_MIN;
  16.     kcp->cwnd = 1;  // 动态调整拥塞控制窗口 
  17.     kcp->incr = kcp->mss;
  18. }
  19.  
  20. if (kcp->cwnd < 1) {
  21.     kcp->cwnd = 1;  
  22.     kcp->incr = kcp->mss;
  23. }
2.3、kcp 报文接收

ikcp_recv
应用层接收函数为 ikcp_recv，主要做三件事

读取组好包的数据 rcv_queue -> 用户 buffer
将接收缓存 rcv_buf 的分片转移到接收队列 rcv_queue
如果有接收空间则将 kcp->probe |= IKCP_ASK_TELL ; 以在update的时候告知对方可以发送数据了。
首先检测一下本次接收数据之后，是否需要进行窗口恢复。在前面的内容中解释过，KCP 协议在远端窗口为0的时候将会停止发送数据，此时如果远端调用 ikcp_recv 将数据从 rcv_queue 中移动到应用层 buffer 中之后，表明其可以再次接受数据，为了能够恢复数据的发送，远端可以主动发送 IKCP_ASK_TELL 来告知窗口大小；
 

  1. if (kcp->nrcv_que >= kcp->rcv_wnd)
  2.     recover = 1;  // 标记可以开始窗口恢复

开始将 rcv_queue 中的数据根据分片编号 frg merge 起来，然后拷贝到用户的 buffer 中。

  1. // merge fragment   
  2. // 将属于同一个消息的各分片重组完整数据，并删除rcv_queue中segment，nrcv_que减少 
  3. // 经过 ikcp_send 发送的数据会进行分片，分片编号为倒序序号，因此frg为0的数据包标记着完整接收到了一次 send 发送过来的数据
  4. for (len = 0, p = kcp->rcv_queue.next; p != &kcp->rcv_queue; ) {
  5.     int fragment;
  6.     seg = iqueue_entry(p, IKCPSEG, node);
  7.     p = p->next;
  8.  
  9.     if (buffer) {
  10.         memcpy(buffer, seg->data, seg->len); // 把queue的数据就放入用户buffer
  11.         buffer += seg->len;
  12.     }
  13.  
  14.     len += seg->len;
  15.     fragment = seg->frg;
  16.  
  17.     if (ikcp_canlog(kcp, IKCP_LOG_RECV)) {
  18.         ikcp_log(kcp, IKCP_LOG_RECV, "recv sn=%lu", (unsigned long)seg->sn);
  19.     }
  20.  
  21.     if (ispeek == 0) {
  22.         iqueue_del(&seg->node);
  23.         ikcp_segment_delete(kcp, seg);  // 删除节点
  24.         kcp->nrcv_que--;    // nrcv_que接收队列-1
  25.     }
  26.  
  27.     // frg = 0，完整的数据接收到, 本次数据接收结束
  28.     if (fragment == 0) 	// 
  29.         break;
  30. }

 下一步将 rcv_buf 中的数据转移到 rcv_queue 中，这个过程根据报文的 sn 编号来确保转移到 rcv_queue 中的数据一定是按序的：

  1. // move available data from rcv_buf -> rcv_queue
  2. // 将 rcv_buf 中的数据转移到 rev_queue 
  3. // 根据报文的sn来确保转移到 rcv_queue 中的数据一定是按序的
  4. while (! iqueue_is_empty(&kcp->rcv_buf)) {
  5.     seg = iqueue_entry(kcp->rcv_buf.next, IKCPSEG, node);
  6.     // 1、根据 sn 确保数据是按序转移到 rcv_queue 中
  7.     // 2、接收队列nrcv_que < 接收窗口rcv_wnd; 
  8.     if (seg->sn == kcp->rcv_nxt && kcp->nrcv_que < kcp->rcv_wnd) {
  9.         iqueue_del(&seg->node);
  10.         kcp->nrcv_buf--;
  11.         iqueue_add_tail(&seg->node, &kcp->rcv_queue);
  12.         kcp->nrcv_que++;    // 接收队列 有多少个分片 + 1
  13.         kcp->rcv_nxt++;     // 接收序号 + 1
  14.     } else {
  15.         break;
  16.     }
  17. }

 最后进行窗口恢复。此时如果 recover 标记为1，表明在此次接收之前，可用接收窗口为0，如果经过本次接收之后，可用窗口大于0，将主动发送 IKCP_ASK_TELL 数据包来通知对方已可以接收数据：

  1. // fast recover 
  2. // nrcv_que小于rcv_wnd, 说明接收端有空间继续接收数据了
  3. if (kcp->nrcv_que < kcp->rcv_wnd && recover) {
  4.     // ready to send back IKCP_CMD_WINS in ikcp_flush
  5.     // tell remote my window size
  6.     kcp->probe |= IKCP_ASK_TELL;
  7. }

 kcp_input

 

ikcp_recv 仅为上层调用的接口，KCP 协议需要从底层接受数据到 rcv_buf 中，这是通过函数 ikcp_input 实现。ikcp_input 中的所有功能都在一个外层的循环中实现：

首先将接收到的数据包进行解码，并进行基本的数据包长度和类型校验；KCP 协议只会接收到前文中所介绍的四种数据包；

调用 ikcp_parse_una 来确定已经发送的数据包有哪些被对方接收到。KCP 中所有的报文类型均带有 una 信息。发送端发送的数据都会缓存在 snd_buf 中，直到接收到对方确认信息之后才会删除。当接收到 una 信息后，表明 sn 小于 una 的数据包都已经被对方接收到，因此可以直接从 snd_buf 中删除。同时调用 ikcp_shrink_buf 来更新 KCP 控制块的 snd_una 数值。

  1. // 删除小于snd_buf中小于una的segment
  2. ikcp_parse_una(kcp, una);       
  3. // 更新snd_una为snd_buf中seg->sn或kcp->snd_nxt ，更新下一个待应答的序号
  4. ikcp_shrink_buf(kcp);

处理 IKCP_CMD_ACK 报文

  1. if (cmd == IKCP_CMD_ACK) {
  2.     if (_itimediff(kcp->current, ts) >= 0) { // 根据应答判断rtt
  3.         //更新rx_srtt，rx_rttval，计算kcp->rx_rto
  4.         ikcp_update_ack(kcp, _itimediff(kcp->current, ts));
  5.     }
  6.     //遍历snd_buf中（snd_una, snd_nxt），将sn相等的删除，直到大于sn  
  7.     ikcp_parse_ack(kcp, sn);    // 将已经ack的分片删除
  8.     ikcp_shrink_buf(kcp);       // 更新控制块的 snd_una
  9.     if (flag == 0) {
  10.         flag = 1;       //快速重传标记
  11.         maxack = sn;    // 记录最大的 ACK 编号
  12.         latest_ts = ts;
  13.     }	else {
  14.         if (_itimediff(sn, maxack) > 0) {
  15.             maxack = sn;        // 记录最大的 ACK 编号 
  16.             latest_ts = ts;
  17.         }
  18.     }

处理 IKCP_CMD_PUSH 报文

  1. else if (cmd == IKCP_CMD_PUSH) {	//接收到具体的数据包
  2.     if (_itimediff(sn, kcp->rcv_nxt + kcp->rcv_wnd) < 0) {
  3.          // 对该报文的确认 ACK 报文放入 ack 列表中
  4.         ikcp_ack_push(kcp, sn, ts);
  5.         //  判断接收的数据分片编号是否符合要求，即：在接收窗口（滑动窗口）范围之内
  6.         if (_itimediff(sn, kcp->rcv_nxt) >= 0) {    // 是要接受起始的序号
  7.             seg = ikcp_segment_new(kcp, len);
  8.             seg->conv = conv;
  9.             seg->cmd = cmd;
  10.             seg->frg = frg;
  11.             seg->wnd = wnd;
  12.             seg->ts = ts;
  13.             seg->sn = sn;
  14.             seg->una = una;
  15.             seg->len = len;
  16.  
  17.             if (len > 0) {
  18.                 memcpy(seg->data, data, len);
  19.             }
  20. 		   
  21.             // 将该报文插入到 rcv_buf 链表中
  22.             ikcp_parse_data(kcp, seg);  
  23.         }
  24.     }
  25. }

对于接收到的 IKCP_CMD_WASK 报文，直接标记下次将发送窗口通知报文；而对于报文 IKCP_CMD_WINS 无需做任何特殊操作;

  1. else if (cmd == IKCP_CMD_WASK) {		
  2.     // ready to send back IKCP_CMD_WINS in ikcp_flush 
  3.     // tell remote my window size 
  4.     // 如果是探测包，添加相应的标识位
  5.     kcp->probe |= IKCP_ASK_TELL;        
  6. }
  7. else if (cmd == IKCP_CMD_WINS) {
  8.     // do nothing，如果是 tell me 远端窗口大小，什么都不做
  9. }

据记录的最大的 ACK 编号 maxack 来更新 snd_buf 中的报文的 fastack，这个过程在介绍 ikcp_flush 中提到过，对于 fastack 大于设置的 resend 参数时，将立马进行快重传；

最后，根据接收到报文的 una 和 KCP 控制块的 una 参数进行流控；
 

文章知识点与官方知识档案匹配，可进一步学习相关知识
网络技能树支撑应用程序的协议应用层的作用48388 人正在系统学习中
KCP网络传输协议
甜筒八部 的专栏
10-24 3598
概念 KCP - A Fast and Reliable ARQ Protocol，KCP 快速可靠网络传输协议 KCP力求在保证可靠性的情况下提高传输速度。kcp采取一系列措施尽量提高网络传输速率，在网络实时性和可靠性要求比较高的场景下，可以考虑kcp协议代替tcp协议。 KCP是一种快速可靠协议，KCP以比 TCP浪费10%-20%带宽的代价，换取了平均延迟降低 30%-40%的效果，且最大延迟降低三倍的传输效果。 整个协议只有 ikcp.h, ikcp.c两个源文件，可以方便的集成到用户自己的
快速可靠协议 - KCP
Skywind Inside
04-15 1万+
快速可靠协议 URL: https://code.google.com/p/ikcp/  KCP是一个快速可靠协议，能以比 TCP浪费10%-20%的带宽的代价，换取平均延迟降低 30%-40%，且最大延迟降低三倍的传输效果。纯算法实现，并不负责底层协议（如UDP）的收发，需要使用者自己定义下层数据包的发送方式，并以 callback的方式提供给 KCP。连时钟都需要外部传递进来，内部
KCP协议
11-18
kcp-netty: kcp的Java语⾔实现,基于netty。 java-kcp: JAVA版本KCP,基于netty实现(包含fec功能) kcp-go: ⾼安全性的kcp的 GO语⾔实现,包含 UDP会话管理的简单实现,可以作为后续开发的基础库。 kcp-csharp: kcp的 csharp移植,同时包含⼀份回话管理,可以连接上⾯kcp-go的服务端。 kcp-csharp: 新版本...
源码刨析 KCP 可靠传输机制
11-15
staticchar*ikcp_encode_seg(char*ptr,constIKCPSEG *seg){ ptr =ikcp_encode32u(ptr, seg->conv); ptr =ikcp_encode8u(ptr, (IUINT8)seg->cmd); ptr =ikcp_encode8u(ptr, (IUINT8)seg->frg); ptr =ikcp_encode16u(ptr, (IUINT16)seg->wnd); ptr =ikcp_encode32u(ptr, seg->ts);...
快速可靠协议：KCP
热门推荐
linshuhe1的专栏
08-12 1万+
KCP 是一个快速可靠协议，能以比 TCP浪费10%-20%的带宽的代价，换取平均延迟降低 30%-40%，且最大延迟降低三倍的传输效果。纯算法实现，并不负责底层协议（如UDP）的收发，需要使用者自己定义下层数据包的发送方式，以 callback的方式提供给 KCP。连时钟都需要外部传递进来，内部不会有任何一次系统调用。 整个协议只有 ikcp.h, ikcp.c两个源文件，可以方便的集成到
KCP实现原理探析
最新发布
程序员老六的专栏
09-06 1175
KCP 是一个轻量级的、高效的、面向 UDP 的传输协议库，专为需要低延迟和高可靠性的实时应用设计。本文针对 KCP 的主要机制和实现与原理进行分析。
KCP-可靠传输协议介绍_kcp协议
11-12
KCP:KCP 是一种在 UDP 基础上实现的可靠传输协议,通过使用前向纠错和重传机制来提供可靠的数据传输。 2. 延迟和吞吐量: TCP:由于 TCP 的拥塞控制和流控机制,它在传输速度和吞吐量方面相对较低,但具有较好的可靠性。 UDP:UDP 不需要进行拥塞控制和流控,并且没有数据包确认和重传机制,因此具有较低的传输延迟和较...
可基于udp的可靠传输协议kcp介绍,C++测试kcp示例_kcp协议
11-13
KCP常用接口 KCP测试源码 KCP简介 KCP是国人开发的开源项目,作者:林伟 (skywind3000)(这个是真大牛)。 KCP是快速可靠传输协议,纯算法实现,KCP无任何系统调用,不负责底层协议收发,底层可以使用UDP或其他自定义协议进行收发。 开源地址:https://github.com/skywind3000/kcp ...
kcp：KCP-一种快速可靠的ARQ协议
02-17
KCP-一种快速可靠的ARQ协议 简介 KCP是一个快速可靠的协议，能以比TCP浪费10％-20％的带宽的代价，换取平均延迟降低30％-40％，并且最大延迟降低三倍的传输效果。纯算法实现，并不负责任协议（如UDP）的收发，需要用户自己定义的下层数据包的发送方式，以回调的方式提供给KCP。连时钟都需要外部传递进来，内部不会有任何一次系统调用。 整个协议只有ikcp.h，ikcp.c两个源文件，可以方便的集成到用户自己的协议栈中。也许你实现了一个P2P，或者基于UDP的协议，而缺乏一套完善的ARQ可靠协议实现，那么简单的副本这两个文件到现有项目中，只需编写两行代码，即可使用。 技术特性 TCP是为流量设计的（每秒内可以传输多少KB的数据），讲究的是充分利用带宽。而KCP是为流量设计的（从数据包从一端发送到一端需要多少时间），以10％- TCP通道是一条非常慢，但连续流量很大的大运河，而KCP是
KCP协议
weixin_46120107的博客
04-09 1015
在网络中，我们认为传输是不可靠的，但是在很多实际的场景中，我们需要得到可靠的数据。得到可靠的数据:数据能够正确到达并且有序。(注意这里有两个条件,一个是有序，一个收到为了达到这个目的，操作系统的协议栈的传输层采用了ARQ协议。TCP采用的就是AQR协议。为什么通常我们认为网络上的传输是不可靠的？(GPT回答,这里我们稍微了解一下)1.数据包丢失:在网络传输过程中,数据包可能会因为各种原因丢失，例如网络拥塞、错误路由等，这会导致传输中部分数据丢失或损坏。
【Linux从青铜到王者】第二十三篇:Linux网络基础第四篇之kcp协议...
11-2
KCP 的数据格式如下图所示: KCP 的发送和接收单元是 segment,即应用层的数据可能会拆分成多个 segment 发送: conv:会话编号。 cmd:segment 类型,IKCP_CMD_ACK、IKCP_CMD_PUSH、IKCP_CMD_WASK、IKCP_CMD_WINS。 frg:是否最后一个 segment。0:数据包的最后一个 segment;1:数据包的中间切片 segment。
网络编程中网络传输KCP协议原理解析
10-30
为了提高udp可靠性,在udp协议上封装一层可靠性传输机制(类似tcp的ACK机制、重传机制、序号机制、重排机制、窗口机制),就做到了兼具tcp的安全性(流量控制和拥塞控制等)和udp的实时性,并且具备一定的灵活性(超时重传、ack等),其中一个代表是kcp协议。 TCP的特点是可靠传输(累积确认、超时重传、选择确认)、流量控制(滑...
可靠UDP，KCP协议快在哪？
weixin_33841722的博客
06-16 2208
作者：许敏华，腾讯IEG高级工程师商业转载请联系腾讯WeTest获得授权，非商业转载请注明出处。原文链接：http://wetest.qq.com/lab/view... WeTest 导读 云真机已经支持手机端的画面投影。云真机实时操作，对延迟的要求比远程视频对话的要求更高（100ms以内）。在无线网络下，如何更实时、更可靠的传输视频流...
KCP 协议 YES
qfzhangwei的专栏
05-01 242
Kcp 是一个非常简单和快速的，基于 KCP 协议的 UDP 隧道，它可以将 TCP 流转换为 KCP+UDP 流。而 KCP 是一个快速可靠协议，能以比 TCP 浪费10%-20%的带宽的代价，换取平均延迟降低 30%-40%，且最大延迟降低三倍的传输效果。纯算法实现，并不负责底层协议(如UDP) 的收发，需要使用者自己定义下层数据包的发送方式，以 callback的方式提供给 KCP。连时钟都需要外部传递进来，内部不会有任何一次系统调用。 整个协议只有 ikcp.h, ikcp.c两个源文件，可以方便的
KCP原理与源码解析
10-31
这个才是KCP真正的头部格式 这是KCP对象,发送接收的数据由KCP对象管理 // ts_xxx 时间戳相关// wnd 窗口相关// snd发送相关// rcv接收相关structIKCPCB{IUINT32 conv;// 标识会话IUINT32 mtu;// 最大传输单元,默认数据为1400,最小为50IUINT32 mss;// 最大分片大小,不大于mtuIUINT32 state;// 连接状态...
C#网络层 Kcp研究_c# kcp
11-8
kcp就是一个带序号的网络协议,纯算法实现。他与tcp协议有些地方很像,但做了改良。 先说结论,应用层我所理解他比tcp好的地方是。 kcp优点 1.他的协议也和tcp一样是安全的 2.他的很多参数是可配的,比如dead_link,时间片,重传几次条件,滑动窗口大小,数据片大小等 ...
快速可靠网络传输协议KCP.zip
07-18
asio-kcp: 使用 KCP的完整 UDP网络库，完整实现了基于 UDP的链接状态管理，会话控制，KCP协议调度等 协议比较 如果永远不丢包那么 KCP和 TCP性能差不多，但网络会卡，造成卡的原因就是丢包和抖动...
可靠udp协议kcp
01-14
kcp可靠udp协议，c源码，仅供参考，可以编译到任何游戏中。
基于KCP协议的P2P服务器和客户端
10-24
1.基于kcp协议，实现UDP消息客户端。2.基于kcp协议，实现UDP消息服务器。
KCP协议探索
weixin_43742796的博客
09-25 666
项目地址 KCP的包头： |<------------ 4 bytes ------------>| +--------+--------+--------+--------+ | conv | conv：Conversation, 会话序号，upd是无连接的，conv用来标识来自哪一个客户端，对连接的一种替代 +--------+--------+--------+--------+ cmd: command，用于标识指令，例如：pus
KCP协议学习（含简单kcp通信Demo）
qq_39280493的博客
12-14 6417
KCP协议学习（含简单kcp通信Demo） 最近公司项目需要使用KCP通信，网上查找了下资料，介绍的挺多，但含有demo的却没有，kcp官网上的demo又高大上，对于新手极不友好，于是自己边学习边研究，文末附上自己写的demo，不足之处，欢迎斧正。 KCP：一种快速可靠的ARQ协议 KCP是一个快速可靠的协议，能以比TCP浪费10％-20％的带宽的代价，换取平均延迟降低30％-40％，并且最大延迟...
KCP协议：从TCP到UDP家族QUIC/KCP/ENET协议对比
m0_68918744的博客
04-01 1058
KCP协议科普 KCP是一个快速可靠协议，能以比 TCP浪费10%-20%的带宽的代价，换取平均延迟降低 30%-40%，且最大延迟降低三倍的传输效果。 纯算法实现，并不负责底层协议（如UDP）的收发，需要使用者自己定义下层数据包的发送方式，以 callback的方式提供给 KCP。 连时钟都需要外部传递进来，内部不会有任何一次系统调用。本文传输协议之考虑UDP的情况。 整个KCP协议主要依靠一个循环ikcp_update来驱动整个算法的运转，所有的数据发送，接收，状态变化都依赖于此，所以如果有操作占
UDP可靠传输协议KCP （Linux C/C++）
C/C++Linux、音视频、DPDK
11-10 653
对于接收方来说，若一个序号为n的分组被正确接收，并且按序，则接收方会为该分组返 回一个ACK给发送方，并将该分组中的数据交付给上层。若该分组是以前没收到的分组，则被缓存。若该分组的序号等于基序号4， 则该分组以及以前缓存的序号连续的分组都交付给上层，然后，接收窗口将向前移动。ARQ模型响应有两种，UNA（此编号前所有包已收到，如TCP）和ACK（该编号包已收到），光用UNA将导致全部重传，光用ACK则丢失成本太高，以往协议都是二选其一，而 KCP协议中，除去单独的 ACK包外，所有包都有UNA信息。
KcpTest压缩包 - 深入理解KCP协议测试程序
- 验证KCP协议在各种网络条件下的表现，确保其在网络不稳定时仍能保持高效和稳定。 - 通过测试，可以收集KCP协议的数据传输性能指标，包括传输速率、丢包率、延迟等。 5. 测试程序的使用和操作： - 用户需要解压...
创作活动
新手引导 客服 举报 返回顶部